package com.example.learn.juc.future;

import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ExecutionException;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author 王明
 * @date 2025/10/24 23:36
 */
public class CFDemo4 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        CompletableFuture<Integer> future = CompletableFuture
//                .supplyAsync(new Supplier<Integer>() {
//                    @Override
//                    public Integer get() {
//                        int number = new Random().nextInt(30);
//                        System.out.println("第一阶段：" + number);
//                        return number;
//                    }
//                })
//                .thenCompose(new Function<Integer, CompletionStage<Integer>>() {
//                    @Override
//                    public CompletionStage<Integer> apply(Integer param) {
//                        return CompletableFuture.supplyAsync(new Supplier<Integer>() {
//                            @Override
//                            public Integer get() {
//                                int number = param * 2;
//                                System.out.println("第二阶段：" + number);
//                                return number;
//                            }
//                        });
//                    }
//                });
//        System.out.println("最终结果: " + future.get());
        //thenApply 和 thenCompose的区别
        //- thenApply转换的是泛型中的类型，并返回一个新的封装了转换结果的
        //CompletableFuture实例；
        //- thenCompose 将内部的 CompletableFuture
        // 调用展开来并使用上一个CompletableFutre 调用的结果在下一步的 CompletableFuture 调用中进行运算，是生成一个新的CompletableFuture。
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
        //thenApply 接收一个函数作为参数，使用该函数处理上一个CompletableFuture 调用的结果，并返回一个具有处理结果的Future对象。
        CompletableFuture<String> result1 = future.thenApply(param -> param + " World");
        //thenCompose 的参数为一个返回 CompletableFuture 实例的函数，该函数的参数是先前计算步骤的结果。
        CompletableFuture<String> result2 = future
                .thenCompose(param -> CompletableFuture.supplyAsync(() -> param + " World"));

        System.out.println(result1.get());
        System.out.println(result2.get());
    }
}
